package com.osce.basic.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.csce.domain.entity.basic.TabAssetInventory;
import com.csce.domain.entity.basic.TabAssetInventoryConsumable;
import com.osce.basic.mapper.TabAssetInventoryConsumableMapper;
import com.osce.common.utils.DateUtils;
import com.osce.interfaces.basic.ITabAssetInventoryConsumableService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * 资产耗材Service业务层处理
 *
 * @author hdj
 * @since 2025-11-15
 */
@Service
public class TabAssetInventoryConsumableServiceImpl extends ServiceImpl<TabAssetInventoryConsumableMapper, TabAssetInventoryConsumable> implements ITabAssetInventoryConsumableService {


    /**
     * 查询资产耗材
     *
     * @param id 资产耗材主键
     * @return 资产耗材
     */
    @Override
    public TabAssetInventoryConsumable selectTabAssetInventoryConsumableById(Long id) {
        return baseMapper.selectTabAssetInventoryConsumableById(id);
    }

    /**
     * 查询资产耗材列表
     *
     * @param tabAssetInventoryConsumable 资产耗材
     * @return 资产耗材
     */
    @Override
    public List<TabAssetInventoryConsumable> selectTabAssetInventoryConsumableList(TabAssetInventoryConsumable tabAssetInventoryConsumable) {
        return baseMapper.selectTabAssetInventoryConsumableList(tabAssetInventoryConsumable);
    }

    /**
     * 新增资产耗材
     *
     * @param tabAssetInventoryConsumable 资产耗材
     * @return 结果
     */
    @Override
    public int insertTabAssetInventoryConsumable(TabAssetInventoryConsumable tabAssetInventoryConsumable) {
        try {
            // 校验编号是否重复
            TabAssetInventoryConsumable existItem = baseMapper.selectOne(
                new LambdaQueryWrapper<TabAssetInventoryConsumable>()
                    .eq(TabAssetInventoryConsumable::getNo, tabAssetInventoryConsumable.getNo())
                    .eq(TabAssetInventoryConsumable::getDeleted, 0)
            );
            if (existItem != null) {
                // 编号已存在，记录错误日志并返回 -1
                System.err.println("【耗材编号重复错误】编号：" + tabAssetInventoryConsumable.getNo() + " 已存在，无法插入");
                return -1;
            }
            // 设置创建时间和入库时间
            tabAssetInventoryConsumable.setCreateTime(DateUtils.getNowDate());
            tabAssetInventoryConsumable.setStorageDate(DateUtils.getNowDate());
            return baseMapper.insertTabAssetInventoryConsumable(tabAssetInventoryConsumable);

        } catch (Exception e) {
            // 记录异常日志
            System.err.println("【耗材插入异常】编号：" + tabAssetInventoryConsumable.getNo() + "，异常信息：" + e.getMessage());
            e.printStackTrace();
            // 抛出运行时异常，让上层处理
            throw new RuntimeException("耗材数据插入失败：" + e.getMessage());
        }
    }

    /**
     * 修改资产耗材
     *
     * @param tabAssetInventoryConsumable 资产耗材
     * @return 结果
     */
    @Override
    public int updateTabAssetInventoryConsumable(TabAssetInventoryConsumable tabAssetInventoryConsumable) {
        return baseMapper.updateTabAssetInventoryConsumable(tabAssetInventoryConsumable);
    }

    /**
     * 批量删除资产耗材
     *
     * @param ids 需要删除的资产耗材主键
     * @return 结果
     */
    @Override
    public int deleteTabAssetInventoryConsumableByIds(Long[] ids) {
        return baseMapper.deleteTabAssetInventoryConsumableByIds(ids);
    }

    /**
     * 删除资产耗材信息
     *
     * @param id 资产耗材主键
     * @return 结果
     */
    @Override
    public int deleteTabAssetInventoryConsumableById(Long id) {
        return baseMapper.deleteTabAssetInventoryConsumableById(id);
    }

    /**
     * 导入资产耗材数据
     *
     * @param tabAssetInventoryConsumableList 导入资产耗材列表
     * @return 结果
     */
    @Override
    public String importTabAssetInventoryConsumable(List<TabAssetInventoryConsumable> tabAssetInventoryConsumableList) {
        StringBuilder resultMsg = new StringBuilder();
        int totalCount = tabAssetInventoryConsumableList.size();
        int successCount = 0;
        int addCount = 0;
        int updateCount = 0;
        int errorCount = 0;
        List<String> errorMessages = new ArrayList<>();

        resultMsg.append("导入结果统计：总共 ").append(totalCount).append(" 条记录\n");

        for (int i = 0; i < tabAssetInventoryConsumableList.size(); i++) {
            TabAssetInventoryConsumable importItem = tabAssetInventoryConsumableList.get(i);

            try {
                // 验证必录字段 - 耗材编号
                if (importItem.getNo() == null || importItem.getNo().trim().isEmpty()) {
                    errorMessages.add("第 " + (i + 1) + " 行：耗材编号不能为空");
                    errorCount++;
                    continue;
                }

                // 验证耗材名称
                if (importItem.getName() == null || importItem.getName().trim().isEmpty()) {
                    errorMessages.add("第 " + (i + 1) + " 行：耗材名称不能为空");
                    errorCount++;
                    continue;
                }

                // 根据耗材编号查询已存在的记录
                TabAssetInventoryConsumable existingItem = new TabAssetInventoryConsumable();
                existingItem.setNo(importItem.getNo());
                List<TabAssetInventoryConsumable> existingList = baseMapper.selectTabAssetInventoryConsumableList(existingItem);

                if (!existingList.isEmpty()) {
                    // 存在重复耗材编号，执行数量累加更新
                    TabAssetInventoryConsumable existing = existingList.get(0);

                    // 累加数量
                    Long existingNumber = existing.getNumber() != null ? existing.getNumber() : 0;
                    Long importNumber = importItem.getNumber() != null ? importItem.getNumber() : 0;
                    existing.setNumber(existingNumber + importNumber);

                    // 更新时间
                    existing.setCreateTime(DateUtils.getNowDate());

                    // 如果导入数据有其他字段值，也进行更新（除了数量）
                    if (importItem.getModel() != null) existing.setModel(importItem.getModel());
                    if (importItem.getRule() != null) existing.setRule(importItem.getRule());
                    if (importItem.getConsumeUnit() != null) existing.setConsumeUnit(importItem.getConsumeUnit());
                    if (importItem.getFixedType() != null) existing.setFixedType(importItem.getFixedType());
                    if (importItem.getType() != null) existing.setType(importItem.getType());
                    if (importItem.getStatus() != null) existing.setStatus(importItem.getStatus());
                    if (importItem.getPrice() != null) existing.setPrice(importItem.getPrice());
                    if (importItem.getVender() != null) existing.setVender(importItem.getVender());
                    if (importItem.getServiceTel() != null) existing.setServiceTel(importItem.getServiceTel());
                    if (importItem.getVenderTel() != null) existing.setVenderTel(importItem.getVenderTel());
                    if (importItem.getWarrantyDate() != null) existing.setWarrantyDate(importItem.getWarrantyDate());
                    if (importItem.getWarningNumber() != null) existing.setWarningNumber(importItem.getWarningNumber());
                    if (importItem.getFactoryDate() != null) existing.setFactoryDate(importItem.getFactoryDate());
                    if (importItem.getStorageDate() != null) existing.setStorageDate(importItem.getStorageDate());
                    if (importItem.getStoragePlace() != null) existing.setStoragePlace(importItem.getStoragePlace());
                    if (importItem.getNowPlace() != null) existing.setNowPlace(importItem.getNowPlace());
                    if (importItem.getCharge() != null) existing.setCharge(importItem.getCharge());
                    if (importItem.getBorrower() != null) existing.setBorrower(importItem.getBorrower());
                    if (importItem.getRemark() != null) existing.setRemark(importItem.getRemark());

                    int updateResult = baseMapper.updateTabAssetInventoryConsumable(existing);
                    if (updateResult > 0) {
                        updateCount++;
                        successCount++;
                        resultMsg.append("耗材编号 '").append(importItem.getNo())
                                .append("' 已存在(更新数量)：原数量 ").append(existingNumber)
                                .append(" + 导入数量 ").append(importNumber)
                                .append(" = 新数量 ").append(existing.getNumber()).append("\n");
                    } else {
                        errorMessages.add("第 " + (i + 1) + " 行：耗材编号 '" + importItem.getNo() + "' 更新失败");
                        errorCount++;
                    }

                } else {
                    // 不存在重复耗材编号，执行新增操作
                    importItem.setCreateTime(DateUtils.getNowDate());
                    importItem.setStorageDate(DateUtils.getNowDate());
                    importItem.setDeleted(0);

                    int insertResult = this.insertTabAssetInventoryConsumable(importItem);
                    if (insertResult > 0) {
                        addCount++;
                        successCount++;
                        resultMsg.append("耗材编号 '").append(importItem.getNo()).append("' 新增成功\n");
                    } else if (insertResult == -1) {
                        // 编号重复错误（从insert方法返回-1）
                        errorMessages.add("第 " + (i + 1) + " 行：耗材编号 '" + importItem.getNo() + "' 已存在，插入失败");
                        errorCount++;
                    } else {
                        // 其他插入失败的情况
                        errorMessages.add("第 " + (i + 1) + " 行：耗材编号 '" + importItem.getNo() + "' 新增失败");
                        errorCount++;
                    }
                }

            } catch (Exception e) {
                String errorMsg = "第 " + (i + 1) + " 行：耗材编号 '" + importItem.getNo() + "' 处理异常：" + e.getMessage();

                // 如果是运行时异常（从insert方法抛出），提取具体错误信息
                if (e instanceof RuntimeException && e.getMessage().contains("耗材数据插入失败")) {
                    errorMsg = "第 " + (i + 1) + " 行：耗材编号 '" + importItem.getNo() + "' 插入失败：" + e.getMessage();
                }

                errorMessages.add(errorMsg);
                errorCount++;

                // 记录详细的异常日志（用于调试）
                System.err.println("【批量导入异常】行号：" + (i + 1) + "，耗材编号：" + importItem.getNo() + "，异常类型：" + e.getClass().getSimpleName() + "，异常信息：" + e.getMessage());
                e.printStackTrace();
            }
        }

        // 生成最终结果报告
        resultMsg.append("\n=== 导入完成统计 ===\n");
        resultMsg.append("成功：").append(successCount).append(" 条\n");
        resultMsg.append("  - 新增：").append(addCount).append(" 条\n");
        resultMsg.append("  - 数量累加更新：").append(updateCount).append(" 条\n");
        resultMsg.append("失败：").append(errorCount).append(" 条\n");

        if (!errorMessages.isEmpty()) {
            resultMsg.append("\n=== 错误详情 ===\n");
            for (String errorMsg : errorMessages) {
                resultMsg.append(errorMsg).append("\n");
            }
        }

        return resultMsg.toString();
    }
}
